home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_grep.idb / usr / freeware / info / grep.info.z / grep.info
Text File  |  2000-04-13  |  34KB  |  863 lines

  1. Ceci est le fichier Info grep.info, produit par Makeinfo version 4.0 α
  2. partir grep.texi.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * grep: (grep).                   print lines matching a pattern.
  6. END-INFO-DIR-ENTRY
  7.    This file documents `grep', a pattern matching engine.
  8.  
  9.    Published by the Free Software Foundation, 59 Temple Place - Suite
  10. 330 Boston, MA 02111-1307, USA
  11.  
  12.    Copyright 2000 Free Software Foundation, Inc.
  13.  
  14.    Permission is granted to make and distribute verbatim copies of this
  15. manual provided the copyright notice and this permission notice are
  16. preserved on all copies.
  17.  
  18.    Permission is granted to copy and distribute modified versions of
  19. this manual under the conditions for verbatim copying, provided that
  20. the entire resulting derived work is distributed under the terms of a
  21. permission notice identical to this one.
  22.  
  23.    Permission is granted to copy and distribute translations of this
  24. manual into another language, under the above conditions for modified
  25. versions, except that this permission notice may be stated in a
  26. translation approved by the Foundation.
  27.  
  28. 
  29. File: grep.info,  Node: Top,  Next: Introduction,  Up: (dir)
  30.  
  31. Grep
  32. ****
  33.  
  34.    `grep' searches for lines matching a pattern.
  35.  
  36.    This document was produced for version 2.4.2 of GNU `grep'.
  37.  
  38. * Menu:
  39.  
  40. * Introduction::                Introduction.
  41. * Invoking::                    Invoking `grep'; description of options.
  42. * Diagnostics::                 Exit status returned by `grep'.
  43. * Grep Programs::               `grep' programs.
  44. * Regular Expressions::         Regular Expressions.
  45. * Usage::                       Examples.
  46. * Reporting Bugs::              Reporting Bugs.
  47. * Concept Index::               A menu with all the topics in this manual.
  48. * Index::                       A menu with all `grep' commands
  49.                                  and command-line options.
  50.  
  51. 
  52. File: grep.info,  Node: Introduction,  Next: Invoking,  Prev: Top,  Up: Top
  53.  
  54. Introduction
  55. ************
  56.  
  57.    `grep' searches the input files for lines containing a match to a
  58. given pattern list.  When it finds a match in a line, it copies the
  59. line to standard output (by default), or does whatever other sort of
  60. output you have requested with options.
  61.  
  62.    Though `grep' expects to do the matching on text, it has no limits
  63. on input line length other than available memory, and it can match
  64. arbitrary characters within a line.  If the final byte of an input file
  65. is not a newline, `grep' silently supplies one.  Since newline is also
  66. a separator for the list of patterns, there is no way to match newline
  67. characters in a text.
  68.  
  69. 
  70. File: grep.info,  Node: Invoking,  Next: Diagnostics,  Prev: Introduction,  Up: Top
  71.  
  72. Invoking `grep'
  73. ***************
  74.  
  75.    `grep' comes with a rich set of options from POSIX.2 and GNU
  76. extensions.
  77.  
  78. `-c'
  79. `--count'
  80.      Suppress normal output; instead print a count of matching lines
  81.      for each input file.  With the `-v', `--invert-match' option,
  82.      count non-matching lines.
  83.  
  84. `-e PATTERN'
  85. `--regexp=PATTERN'
  86.      Use PATTERN as the pattern; useful to protect patterns beginning
  87.      with a `-'.
  88.  
  89. `-f FILE'
  90. `--file=FILE'
  91.      Obtain patterns from FILE, one per line.  The empty file contains
  92.      zero patterns, and therefore matches nothing.
  93.  
  94. `-i'
  95. `--ignore-case'
  96.      Ignore case distinctions in both the pattern and the input files.
  97.  
  98. `-l'
  99. `--files-with-matches'
  100.      Suppress normal output; instead print the name of each input file
  101.      from which output would normally have been printed.  The scanning
  102.      of every file will stop on the first match.
  103.  
  104. `-n'
  105. `--line-number'
  106.      Prefix each line of output with the line number within its input
  107.      file.
  108.  
  109. `-q'
  110. `--quiet'
  111. `--silent'
  112.      Quiet; suppress normal output.  The scanning of every file will
  113.      stop on the first match.  Also see the `-s' or `--no-messages'
  114.      option.
  115.  
  116. `-s'
  117. `--no-messages'
  118.      Suppress error messages about nonexistent or unreadable files.
  119.      Portability note: unlike GNU `grep', traditional `grep' did not
  120.      conform to POSIX.2, because traditional `grep' lacked a `-q'
  121.      option and its `-s' option behaved like GNU `grep''s `-q' option.
  122.      Shell scripts intended to be portable to traditional `grep' should
  123.      avoid both `-q' and `-s' and should redirect output to `/dev/null'
  124.      instead.
  125.  
  126. `-v'
  127. `--invert-match'
  128.      Invert the sense of matching, to select non-matching lines.
  129.  
  130. `-x'
  131. `--line-regexp'
  132.      Select only those matches that exactly match the whole line.
  133.  
  134. GNU Extensions
  135. ==============
  136.  
  137. `-A NUM'
  138. `--after-context=NUM'
  139.      Print NUM lines of trailing context after matching lines.
  140.  
  141. `-B NUM'
  142. `--before-context=NUM'
  143.      Print NUM lines of leading context before matching lines.
  144.  
  145. `-C NUM'
  146. `--context=[NUM]'
  147.      Print NUM lines (default 2) of output context.
  148.  
  149. `-NUM'
  150.      Same as `--context=NUM' lines of leading and trailing context.
  151.      However, grep will never print any given line more than once.
  152.  
  153. `-V'
  154. `--version'
  155.      Print the version number of `grep' to the standard output stream.
  156.      This version number should be included in all bug reports.
  157.  
  158. `--help'
  159.      Print a usage message briefly summarizing these command-line
  160.      options and the bug-reporting address, then exit.
  161.  
  162. `--binary-files=TYPE'
  163.      If the first few bytes of a file indicate that the file contains
  164.      binary data, assume that the file is of type TYPE.  By default,
  165.      TYPE is `binary', and `grep' normally outputs either a one-line
  166.      message saying that a binary file matches, or no message if there
  167.      is no match.  If TYPE is `without-match', `grep' assumes that a
  168.      binary file does not match; this is equivalent to the `-I' option.
  169.      If TYPE is `text', `grep' processes a binary file as if it were
  170.      text; this is equivalent to the `-a' option.  _Warning:_
  171.      `--binary-files=text' might output binary garbage, which can have
  172.      nasty side effects if the output is a terminal and if the terminal
  173.      driver interprets some of it as commands.
  174.  
  175. `-b'
  176. `--byte-offset'
  177.      Print the byte offset within the input file before each line of
  178.      output.  When `grep' runs on MS-DOS or MS-Windows, the printed
  179.      byte offsets depend on whether the `-u' (`--unix-byte-offsets')
  180.      option is used; see below.
  181.  
  182. `-d ACTION'
  183. `--directories=ACTION'
  184.      If an input file is a directory, use ACTION to process it.  By
  185.      default, ACTION is `read', which means that directories are read
  186.      just as if they were ordinary files (some operating systems and
  187.      filesystems disallow this, and will cause `grep' to print error
  188.      messages for every directory).  If ACTION is `skip', directories
  189.      are silently skipped.  If ACTION is `recurse', `grep' reads all
  190.      files under each directory, recursively; this is equivalent to the
  191.      `-r' option.
  192.  
  193. `-H'
  194. `--with-filename'
  195.      Print the filename for each match.
  196.  
  197. `-h'
  198. `--no-filename'
  199.      Suppress the prefixing of filenames on output when multiple files
  200.      are searched.
  201.  
  202. `-L'
  203. `--files-without-match'
  204.      Suppress normal output; instead print the name of each input file
  205.      from which no output would normally have been printed.  The
  206.      scanning of every file will stop on the first match.
  207.  
  208. `-a'
  209. `--text'
  210.      Process a binary file as if it were text; this is equivalent to the
  211.      `--binary-files=text' option.
  212.  
  213. `-I'
  214.      Process a binary file as if it did not contain matching data; this
  215.      is equivalent to the `--binary-files=without-match' option.
  216.  
  217. `-w'
  218. `--word-regexp'
  219.      Select only those lines containing matches that form whole words.
  220.      The test is that the matching substring must either be at the
  221.      beginning of the line, or preceded by a non-word constituent
  222.      character.  Similarly, it must be either at the end of the line or
  223.      followed by a non-word constituent character.  Word-constituent
  224.      characters are letters, digits, and the underscore.
  225.  
  226. `-r'
  227. `--recursive'
  228.      For each directory mentioned in the command line, read and process
  229.      all files in that directory, recursively.  This is the same as the
  230.      `-d recurse' option.
  231.  
  232. `-y'
  233.      Obsolete synonym for `-i'.
  234.  
  235. `-U'
  236. `--binary'
  237.      Treat the file(s) as binary.  By default, under MS-DOS and
  238.      MS-Windows, `grep' guesses the file type by looking at the
  239.      contents of the first 32kB read from the file.  If `grep' decides
  240.      the file is a text file, it strips the `CR' characters from the
  241.      original file contents (to make regular expressions with `^' and
  242.      `$' work correctly).  Specifying `-U' overrules this guesswork,
  243.      causing all files to be read and passed to the matching mechanism
  244.      verbatim; if the file is a text file with `CR/LF' pairs at the end
  245.      of each line, this will cause some regular expressions to fail.
  246.      This option has no effect on platforms other than MS-DOS and
  247.      MS-Windows.
  248.  
  249. `-u'
  250. `--unix-byte-offsets'
  251.      Report Unix-style byte offsets.  This switch causes `grep' to
  252.      report byte offsets as if the file were Unix style text file,
  253.      i.e., the byte offsets ignore the `CR' characters which were
  254.      stripped.  This will produce results identical to running `grep' on
  255.      a Unix machine.  This option has no effect unless `-b' option is
  256.      also used; it has no effect on platforms other than MS-DOS and
  257.      MS-Windows.
  258.  
  259. `--mmap'
  260.      If possible, use the `mmap' system call to read input, instead of
  261.      the default `read' system call.  In some situations, `--mmap'
  262.      yields better performance.  However, `--mmap' can cause undefined
  263.      behavior (including core dumps) if an input file shrinks while
  264.      `grep' is operating, or if an I/O error occurs.
  265.  
  266. `-Z'
  267. `--null'
  268.      Output a zero byte (the ASCII `NUL' character) instead of the
  269.      character that normally follows a file name.  For example, `grep
  270.      -lZ' outputs a zero byte after each file name instead of the usual
  271.      newline.  This option makes the output unambiguous, even in the
  272.      presence of file names containing unusual characters like
  273.      newlines.  This option can be used with commands like `find
  274.      -print0', `perl -0', `sort -z', and `xargs -0' to process
  275.      arbitrary file names, even those that contain newline characters.
  276.  
  277. `-z'
  278. `--null-data'
  279.      Treat the input as a set of lines, each terminated by a zero byte
  280.      (the ASCII `NUL' character) instead of a newline.  Like the `-Z'
  281.      or `--null' option, this option can be used with commands like
  282.      `sort -z' to process arbitrary file names.
  283.  
  284.    Several additional options control which variant of the `grep'
  285. matching engine is used.  *Note Grep Programs::.
  286.  
  287. Environment Variables
  288. =====================
  289.  
  290.    Grep's behavior is affected by the following environment variables.
  291.  
  292. `GREP_OPTIONS'
  293.      This variable specifies default options to be placed in front of
  294.      any explicit options.  For example, if `GREP_OPTIONS' is
  295.      `--binary-files=without-match --directories=skip', `grep' behaves
  296.      as if the two options `--binary-files=without-match' and
  297.      `--directories=skip' had been specified before any explicit
  298.      options.  Option specifications are separated by whitespace.  A
  299.      backslash escapes the next character, so it can be used to specify
  300.      an option containing whitespace or a backslash.
  301.  
  302. `LC_ALL'
  303. `LC_MESSAGES'
  304. `LANG'
  305.      These variables specify the `LC_MESSAGES' locale, which determines
  306.      the language that `grep' uses for messages.  The locale is
  307.      determined by the first of these variables that is set.  American
  308.      English is used if none of these environment variables are set, or
  309.      if the message catalog is not installed, or if `grep' was not
  310.      compiled with national language support (NLS).
  311.  
  312. `LC_ALL'
  313. `LC_CTYPE'
  314. `LANG'
  315.      These variables specify the `LC_CTYPE' locale, which determines the
  316.      type of characters, e.g., which characters are whitespace.  The
  317.      locale is determined by the first of these variables that is set.
  318.      The POSIX locale is used if none of these environment variables
  319.      are set, or if the locale catalog is not installed, or if `grep'
  320.      was not compiled with national language support (NLS).
  321.  
  322. `POSIXLY_CORRECT'
  323.      If set, `grep' behaves as POSIX.2 requires; otherwise, `grep'
  324.      behaves more like other GNU programs.  POSIX.2 requires that
  325.      options that follow file names must be treated as file names; by
  326.      default, such options are permuted to the front of the operand
  327.      list and are treated as options.  Also, POSIX.2 requires that
  328.      unrecognized options be diagnosed as "illegal", but since they are
  329.      not really against the law the default is to diagnose them as
  330.      "invalid".  `POSIXLY_CORRECT' also disables
  331.      `_N_GNU_nonoption_argv_flags_', described below.
  332.  
  333. `_N_GNU_nonoption_argv_flags_'
  334.      (Here `N' is `grep''s numeric process ID.)  If the Ith character
  335.      of this environment variable's value is `1', do not consider the
  336.      Ith operand of `grep' to be an option, even if it appears to be
  337.      one.  A shell can put this variable in the environment for each
  338.      command it runs, specifying which operands are the results of file
  339.      name wildcard expansion and therefore should not be treated as
  340.      options.  This behavior is available only with the GNU C library,
  341.      and only when `POSIXLY_CORRECT' is not set.
  342.  
  343. 
  344. File: grep.info,  Node: Diagnostics,  Next: Grep Programs,  Prev: Invoking,  Up: Top
  345.  
  346. Diagnostics
  347. ***********
  348.  
  349.    Normally, exit status is 0 if matches were found, and 1 if no matches
  350. were found (the `-v' option inverts the sense of the exit status).
  351. Exit status is 2 if there were syntax errors in the pattern,
  352. inaccessible input files, or other system errors.
  353.  
  354. 
  355. File: grep.info,  Node: Grep Programs,  Next: Regular Expressions,  Prev: Diagnostics,  Up: Top
  356.  
  357. `grep' programs
  358. ***************
  359.  
  360.    `grep' searches the named input files (or standard input if no files
  361. are named, or the file name `-' is given) for lines containing a match
  362. to the given pattern.  By default, `grep' prints the matching lines.
  363. There are three major variants of `grep', controlled by the following
  364. options.
  365.  
  366. `-G'
  367. `--basic-regexp'
  368.      Interpret pattern as a basic regular expression.  This is the
  369.      default.
  370.  
  371. `-E'
  372. `--extended-regexp'
  373.      Interpret pattern as an extended regular expression.
  374.  
  375. `-F'
  376. `--fixed-strings'
  377.      Interpret pattern as a list of fixed strings, separated by
  378.      newlines, any of which is to be matched.
  379.  
  380.    In addition, two variant programs EGREP and FGREP are available.
  381. EGREP is the same as `grep -E'.  FGREP is the same as `grep -F'.
  382.  
  383. 
  384. File: grep.info,  Node: Regular Expressions,  Next: Usage,  Prev: Grep Programs,  Up: Top
  385.  
  386. Regular Expressions
  387. *******************
  388.  
  389.    A "regular expression" is a pattern that describes a set of strings.
  390. Regular expressions are constructed analogously to arithmetic
  391. expressions, by using various operators to combine smaller expressions.
  392. `grep' understands two different versions of regular expression syntax:
  393. "basic" and "extended".  In GNU `grep', there is no difference in
  394. available functionality using either syntax.  In other implementations,
  395. basic regular expressions are less powerful.  The following description
  396. applies to extended regular expressions; differences for basic regular
  397. expressions are summarized afterwards.
  398.  
  399.    The fundamental building blocks are the regular expressions that
  400. match a single character.  Most characters, including all letters and
  401. digits, are regular expressions that match themselves.  Any
  402. metacharacter with special meaning may be quoted by preceding it with a
  403. backslash.  A list of characters enclosed by `[' and `]' matches any
  404. single character in that list; if the first character of the list is the
  405. caret `^', then it matches any character *not* in the list.  For
  406. example, the regular expression `[0123456789]' matches any single digit.
  407. A range of characters may be specified by giving the first and last
  408. characters, separated by a hyphen.
  409.  
  410.    Finally, certain named classes of characters are predefined, as
  411. follows.  Their interpretation depends on the `LC_CTYPE' locale; the
  412. interpretation below is that of the POSIX locale, which is the default
  413. if no `LC_CTYPE' locale is specified.
  414.  
  415. `[:alnum:]'
  416.      Alphanumeric characters: `[:alpha:]' and `[:digit:]'.
  417.  
  418. `[:alpha:]'
  419.      Alphabetic characters: `[:lower:]' and `[:upper:]'.
  420.  
  421. `[:blank:]'
  422.      Blank characters: space and tab.
  423.  
  424. `[:cntrl:]'
  425.      Control characters.  In ASCII, these characters have octal codes
  426.      000 through 037, and 177 (`DEL').  In other character sets, these
  427.      are the equivalent characters, if any.
  428.  
  429. `[:digit:]'
  430.      Digits: `0 1 2 3 4 5 6 7 8 9'.
  431.  
  432. `[:graph:]'
  433.      Graphical characters: `[:alnum:]' and `[:punct:]'.
  434.  
  435. `[:lower:]'
  436.      Lower-case letters: `a b c d e f g h i j k l m n o p q r s t u v w
  437.      x y z'.
  438.  
  439. `[:print:]'
  440.      Printable characters: `[:alnum:]', `[:punct:]', and space.
  441.  
  442. `[:punct:]'
  443.      Punctuation characters: `! " # $ % & ' ( ) * + , - . / : ; < = > ?
  444.      @ [ \ ] ^ _ ` { | } ~'.
  445.  
  446. `[:space:]'
  447.      Space characters: tab, newline, vertical tab, form feed, carriage
  448.      return, and space.
  449.  
  450. `[:upper:]'
  451.      Upper-case letters: `A B C D E F G H I J K L M N O P Q R S T U V W
  452.      X Y Z'.
  453.  
  454. `[:xdigit:]'
  455.      Hexadecimal digits: `0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f'.
  456.  
  457.    For example, `[[:alnum:]]' means `[0-9A-Za-z]', except the latter
  458. depends upon the POSIX locale and the ASCII character encoding, whereas
  459. the former is independent of locale and character set.  (Note that the
  460. brackets in these class names are part of the symbolic names, and must
  461. be included in addition to the brackets delimiting the bracket list.)
  462. Most metacharacters lose their special meaning inside lists.  To
  463. include a literal `]', place it first in the list.  Similarly, to
  464. include a literal `^', place it anywhere but first.  Finally, to
  465. include a literal `-', place it last.
  466.  
  467.    The period `.' matches any single character.  The symbol `\w' is a
  468. synonym for `[[:alnum:]]' and `\W' is a synonym for `[^[:alnum]]'.
  469.  
  470.    The caret `^' and the dollar sign `$' are metacharacters that
  471. respectively match the empty string at the beginning and end of a line.
  472. The symbols `\<' and `\>' respectively match the empty string at the
  473. beginning and end of a word.  The symbol `\b' matches the empty string
  474. at the edge of a word, and `\B' matches the empty string provided it's
  475. not at the edge of a word.
  476.  
  477.    A regular expression may be followed by one of several repetition
  478. operators:
  479.  
  480. `?'
  481.      The preceding item is optional and will be matched at most once.
  482.  
  483. `*'
  484.      The preceding item will be matched zero or more times.
  485.  
  486. `+'
  487.      The preceding item will be matched one or more times.
  488.  
  489. `{N}'
  490.      The preceding item is matched exactly N times.
  491.  
  492. `{N,}'
  493.      The preceding item is matched n or more times.
  494.  
  495. `{N,M}'
  496.      The preceding item is matched at least N times, but not more than
  497.      M times.
  498.  
  499.    Two regular expressions may be concatenated; the resulting regular
  500. expression matches any string formed by concatenating two substrings
  501. that respectively match the concatenated subexpressions.
  502.  
  503.    Two regular expressions may be joined by the infix operator `|'; the
  504. resulting regular expression matches any string matching either
  505. subexpression.
  506.  
  507.    Repetition takes precedence over concatenation, which in turn takes
  508. precedence over alternation.  A whole subexpression may be enclosed in
  509. parentheses to override these precedence rules.
  510.  
  511.    The backreference `\N', where N is a single digit, matches the
  512. substring previously matched by the Nth parenthesized subexpression of
  513. the regular expression.
  514.  
  515.    In basic regular expressions the metacharacters `?', `+', `{', `|',
  516. `(', and `)' lose their special meaning; instead use the backslashed
  517. versions `\?', `\+', `\{', `\|', `\(', and `\)'.
  518.  
  519.    Traditional `egrep' did not support the `{' metacharacter, and some
  520. `egrep' implementations support `\{' instead, so portable scripts
  521. should avoid `{' in `egrep' patterns and should use `[{]' to match a
  522. literal `{'.
  523.  
  524.    GNU `egrep' attempts to support traditional usage by assuming that
  525. `{' is not special if it would be the start of an invalid interval
  526. specification.  For example, the shell command `egrep '{1'' searches
  527. for the two-character string `{1' instead of reporting a syntax error
  528. in the regular expression.  POSIX.2 allows this behavior as an
  529. extension, but portable scripts should avoid it.
  530.  
  531. 
  532. File: grep.info,  Node: Usage,  Next: Reporting Bugs,  Prev: Regular Expressions,  Up: Top
  533.  
  534. Usage
  535. *****
  536.  
  537.    Here is an example shell command that invokes GNU `grep':
  538.  
  539.      grep -i 'hello.*world' menu.h main.c
  540.  
  541. This lists all lines in the files `menu.h' and `main.c' that contain
  542. the string `hello' followed by the string `world'; this is because `.*'
  543. matches zero or more characters within a line.  *Note Regular
  544. Expressions::.  The `-i' option causes `grep' to ignore case, causing
  545. it to match the line `Hello, world!', which it would not otherwise
  546. match.  *Note Invoking::, for more details about how to invoke `grep'.
  547.  
  548.    Here are some common questions and answers about `grep' usage.
  549.  
  550.   1. How can I list just the names of matching files?
  551.  
  552.           grep -l 'main' *.c
  553.  
  554.      lists the names of all C files in the current directory whose
  555.      contents mention `main'.
  556.  
  557.   2. How do I search directories recursively?
  558.  
  559.           grep -r 'hello' /home/gigi
  560.  
  561.      searches for `hello' in all files under the directory
  562.      `/home/gigi'.  For more control of which files are searched, use
  563.      `find', `grep' and `xargs'.  For example, the following command
  564.      searches only C files:
  565.  
  566.           find /home/gigi -name '*.c' -print | xargs grep 'hello' /dev/null
  567.  
  568.   3. What if a pattern has a leading `-'?
  569.  
  570.           grep -e '--cut here--' *
  571.  
  572.      searches for all lines matching `--cut here--'.  Without `-e',
  573.      `grep' would attempt to parse `--cut here--' as a list of options.
  574.  
  575.   4. Suppose I want to search for a whole word, not a part of a word?
  576.  
  577.           grep -w 'hello' *
  578.  
  579.      searches only for instances of `hello' that are entire words; it
  580.      does not match `Othello'.  For more control, use `\<' and `\>' to
  581.      match the start and end of words.  For example:
  582.  
  583.           grep 'hello\>' *
  584.  
  585.      searches only for words ending in `hello', so it matches the word
  586.      `Othello'.
  587.  
  588.   5. How do I output context around the matching lines?
  589.  
  590.           grep -C 2 'hello' *
  591.  
  592.      prints two lines of context around each matching line.
  593.  
  594.   6. How do I force grep to print the name of the file?
  595.  
  596.      Append `/dev/null':
  597.  
  598.           grep 'eli' /etc/passwd /dev/null
  599.  
  600.   7. Why do people use strange regular expressions on `ps' output?
  601.  
  602.           ps -ef | grep '[c]ron'
  603.  
  604.      If the pattern had been written without the square brackets, it
  605.      would have matched not only the `ps' output line for `cron', but
  606.      also the `ps' output line for `grep'.
  607.  
  608.   8. Why does `grep' report "Binary file matches"?
  609.  
  610.      If `grep' listed all matching "lines" from a binary file, it would
  611.      probably generate output that is not useful, and it might even
  612.      muck up your display.  So GNU `grep' suppresses output from files
  613.      that appear to be binary files.  To force GNU `grep' to output
  614.      lines even from files that appear to be binary, use the `-a' or
  615.      `--binary-files=text' option.  To eliminate the "Binary file
  616.      matches" messages, use the `-I' or `--binary-files=without-match'
  617.      option.
  618.  
  619.   9. Why doesn't `grep -lv' print nonmatching file names?
  620.  
  621.      `grep -lv' lists the names of all files containing one or more
  622.      lines that do not match.  To list the names of all files that
  623.      contain no matching lines, use the `-L' or `--files-without-match'
  624.      option.
  625.  
  626.  10. I can do OR with `|', but what about AND?
  627.  
  628.           grep 'paul' /etc/motd | grep 'franc,ois'
  629.  
  630.      finds all lines that contain both `paul' and `franc,ois'.
  631.  
  632.  11. How can I search in both standard input and in files?
  633.  
  634.      Use the special file name `-':
  635.  
  636.           cat /etc/passwd | grep 'alain' - /etc/motd
  637.  
  638. 
  639. File: grep.info,  Node: Reporting Bugs,  Next: Concept Index,  Prev: Usage,  Up: Top
  640.  
  641. Reporting bugs
  642. **************
  643.  
  644.    Email bug reports to <bug-gnu-utils@gnu.org>.  Be sure to include
  645. the word "grep" somewhere in the "Subject:" field.
  646.  
  647.    Large repetition counts in the `{m,n}' construct may cause `grep' to
  648. use lots of memory.  In addition, certain other obscure regular
  649. expressions require exponential time and space, and may cause grep to
  650. run out of memory.  Backreferences are very slow, and may require
  651. exponential time.
  652.  
  653. 
  654. File: grep.info,  Node: Concept Index,  Next: Index,  Prev: Reporting Bugs,  Up: Top
  655.  
  656. Concept Index
  657. *************
  658.  
  659.    This is a general index of all issues discussed in this manual, with
  660. the exception of the `grep' commands and command-line options.
  661.  
  662. * Menu:
  663.  
  664. * after context:                         Invoking.
  665. * alphabetic characters:                 Regular Expressions.
  666. * alphanumeric characters:               Regular Expressions.
  667. * asterisk:                              Regular Expressions.
  668. * basic regular expressions:             Regular Expressions.
  669. * before context:                        Invoking.
  670. * binary files:                          Invoking.
  671. * binary files, DOS/Windows:             Invoking.
  672. * blank characters:                      Regular Expressions.
  673. * braces, one argument:                  Regular Expressions.
  674. * braces, second argument omitted:       Regular Expressions.
  675. * braces, two arguments:                 Regular Expressions.
  676. * Bugs, reporting:                       Reporting Bugs.
  677. * byte offset:                           Invoking.
  678. * byte offsets, on DOS/Windows:          Invoking.
  679. * case insensitive search:               Invoking.
  680. * case insensitive search, obsolete option: Invoking.
  681. * character classes:                     Regular Expressions.
  682. * character type:                        Invoking.
  683. * classes of characters:                 Regular Expressions.
  684. * context:                               Invoking.
  685. * context lines, after match:            Invoking.
  686. * context lines, before match:           Invoking.
  687. * control characters:                    Regular Expressions.
  688. * counting lines:                        Invoking.
  689. * default options environment variable:  Invoking.
  690. * digit characters:                      Regular Expressions.
  691. * directory search:                      Invoking.
  692. * DOS byte offsets:                      Invoking.
  693. * DOS/Windows binary files:              Invoking.
  694. * environment variables:                 Invoking.
  695. * FAQ about grep usage:                  Usage.
  696. * files which don't match:               Invoking.
  697. * graphic characters:                    Regular Expressions.
  698. * hexadecimal digits:                    Regular Expressions.
  699. * interval specifications:               Regular Expressions.
  700. * invert matching:                       Invoking.
  701. * language of messages:                  Invoking.
  702. * line numbering:                        Invoking.
  703. * lower-case letters:                    Regular Expressions.
  704. * match sub-expression at most once:     Regular Expressions.
  705. * match sub-expression n or more times:  Regular Expressions.
  706. * match sub-expression n times:          Regular Expressions.
  707. * match sub-expression zero or more times: Regular Expressions.
  708. * match the whole line:                  Invoking.
  709. * matching basic regular expressions:    Grep Programs.
  710. * matching extended regular expressions: Grep Programs.
  711. * matching fixed strings:                Grep Programs.
  712. * matching whole words:                  Invoking.
  713. * memory mapped input:                   Invoking.
  714. * message language:                      Invoking.
  715. * names of matching files:               Invoking.
  716. * national language support:             Invoking.
  717. * NLS:                                   Invoking.
  718. * no filename prefix:                    Invoking.
  719. * numeric characters:                    Regular Expressions.
  720. * pattern from file:                     Invoking.
  721. * pattern list:                          Invoking.
  722. * plus sign:                             Regular Expressions.
  723. * print non-matching lines:              Invoking.
  724. * printable characters:                  Regular Expressions.
  725. * punctuation characters:                Regular Expressions.
  726. * question mark:                         Regular Expressions.
  727. * quiet, silent:                         Invoking.
  728. * recursive search:                      Invoking.
  729. * regular expressions:                   Regular Expressions.
  730. * searching directory trees:             Invoking.
  731. * Searching for a pattern.:              Introduction.
  732. * space characters:                      Regular Expressions.
  733. * suppress binary data:                  Invoking.
  734. * suppress error messages:               Invoking.
  735. * translation of message language:       Invoking.
  736. * upper-case letters:                    Regular Expressions.
  737. * Usage summary, printing:               Invoking.
  738. * Usage, examples:                       Usage.
  739. * Using grep, Q&A:                       Usage.
  740. * Version, printing:                     Invoking.
  741. * whitespace characters:                 Regular Expressions.
  742. * with filename prefix:                  Invoking.
  743. * xdigit class:                          Regular Expressions.
  744. * zero-terminated file names:            Invoking.
  745. * zero-terminated lines:                 Invoking.
  746.  
  747. 
  748. File: grep.info,  Node: Index,  Prev: Concept Index,  Up: Top
  749.  
  750. Index
  751. *****
  752.  
  753.    This is an alphabetical list of all `grep' commands, command-line
  754. options, and environment variables.
  755.  
  756. * Menu:
  757.  
  758. * *:                                     Regular Expressions.
  759. * +:                                     Regular Expressions.
  760. * --after-context:                       Invoking.
  761. * --basic-regexp:                        Grep Programs.
  762. * --before-context:                      Invoking.
  763. * --binary:                              Invoking.
  764. * --binary-files:                        Invoking.
  765. * --byte-offset:                         Invoking.
  766. * --context:                             Invoking.
  767. * --directories:                         Invoking.
  768. * --extended-regexp:                     Grep Programs.
  769. * --file:                                Invoking.
  770. * --files-with-matches:                  Invoking.
  771. * --files-without-match:                 Invoking.
  772. * --fixed-strings:                       Grep Programs.
  773. * --help:                                Invoking.
  774. * --ignore-case:                         Invoking.
  775. * --invert-match:                        Invoking.
  776. * --line-number:                         Invoking.
  777. * --line-regexp:                         Invoking.
  778. * --mmap:                                Invoking.
  779. * --no-filename:                         Invoking.
  780. * --no-messages:                         Invoking.
  781. * --null:                                Invoking.
  782. * --null-data:                           Invoking.
  783. * --quiet:                               Invoking.
  784. * --recursive:                           Invoking.
  785. * --regexp=PATTERN:                      Invoking.
  786. * --silent:                              Invoking.
  787. * --text:                                Invoking.
  788. * --unix-byte-offsets:                   Invoking.
  789. * --version:                             Invoking.
  790. * --With-filename:                       Invoking.
  791. * --word-regexp:                         Invoking.
  792. * -a:                                    Invoking.
  793. * -A:                                    Invoking.
  794. * -b:                                    Invoking.
  795. * -B:                                    Invoking.
  796. * -C:                                    Invoking.
  797. * -c:                                    Invoking.
  798. * -count:                                Invoking.
  799. * -d:                                    Invoking.
  800. * -E:                                    Grep Programs.
  801. * -e:                                    Invoking.
  802. * -F:                                    Grep Programs.
  803. * -f:                                    Invoking.
  804. * -G:                                    Grep Programs.
  805. * -h:                                    Invoking.
  806. * -H:                                    Invoking.
  807. * -i:                                    Invoking.
  808. * -L:                                    Invoking.
  809. * -l:                                    Invoking.
  810. * -n:                                    Invoking.
  811. * -NUM:                                  Invoking.
  812. * -q:                                    Invoking.
  813. * -r:                                    Invoking.
  814. * -s:                                    Invoking.
  815. * -u:                                    Invoking.
  816. * -U:                                    Invoking.
  817. * -V:                                    Invoking.
  818. * -v:                                    Invoking.
  819. * -w:                                    Invoking.
  820. * -x:                                    Invoking.
  821. * -y:                                    Invoking.
  822. * -z:                                    Invoking.
  823. * -Z:                                    Invoking.
  824. * ?:                                     Regular Expressions.
  825. * _N_GNU_nonoption_argv_flags_:          Invoking.
  826. * alnum:                                 Regular Expressions.
  827. * alpha:                                 Regular Expressions.
  828. * blank:                                 Regular Expressions.
  829. * cntrl:                                 Regular Expressions.
  830. * digit:                                 Regular Expressions.
  831. * graph:                                 Regular Expressions.
  832. * GREP_OPTIONS:                          Invoking.
  833. * LANG:                                  Invoking.
  834. * LC_ALL:                                Invoking.
  835. * LC_CTYPE:                              Invoking.
  836. * LC_MESSAGES:                           Invoking.
  837. * lower:                                 Regular Expressions.
  838. * POSIXLY_CORRECT:                       Invoking.
  839. * print:                                 Regular Expressions.
  840. * punct:                                 Regular Expressions.
  841. * space:                                 Regular Expressions.
  842. * upper:                                 Regular Expressions.
  843. * xdigit:                                Regular Expressions.
  844. * {n,m}:                                 Regular Expressions.
  845. * {n,}:                                  Regular Expressions.
  846. * {n}:                                   Regular Expressions.
  847.  
  848.  
  849. 
  850. Tag Table:
  851. Node: Top1067
  852. Node: Introduction1839
  853. Node: Invoking2566
  854. Node: Diagnostics13206
  855. Node: Grep Programs13571
  856. Node: Regular Expressions14451
  857. Node: Usage20275
  858. Node: Reporting Bugs23876
  859. Node: Concept Index24407
  860. Node: Index29203
  861. 
  862. End Tag Table
  863.